home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / unittest.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-13  |  23KB  |  744 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. __author__ = 'Steve Purcell'
  5. __email__ = 'stephen_purcell at yahoo dot com'
  6. __version__ = '#Revision: 1.63 $'[11:-2]
  7. import time
  8. import sys
  9. import traceback
  10. import os
  11. import types
  12. __all__ = [
  13.     'TestResult',
  14.     'TestCase',
  15.     'TestSuite',
  16.     'TextTestRunner',
  17.     'TestLoader',
  18.     'FunctionTestCase',
  19.     'main',
  20.     'defaultTestLoader']
  21. __all__.extend([
  22.     'getTestCaseNames',
  23.     'makeSuite',
  24.     'findTestCases'])
  25. if sys.version_info[:2] < (2, 2):
  26.     (False, True) = (0, 1)
  27.     
  28.     def isinstance(obj, clsinfo):
  29.         import __builtin__ as __builtin__
  30.         if type(clsinfo) in (tuple, list):
  31.             for cls in clsinfo:
  32.                 if cls is type:
  33.                     cls = types.ClassType
  34.                 
  35.                 if __builtin__.isinstance(obj, cls):
  36.                     return 1
  37.                     continue
  38.             
  39.             return 0
  40.         else:
  41.             return __builtin__.isinstance(obj, clsinfo)
  42.  
  43.  
  44. __metaclass__ = type
  45.  
  46. def _strclass(cls):
  47.     return '%s.%s' % (cls.__module__, cls.__name__)
  48.  
  49. __unittest = 1
  50.  
  51. class TestResult:
  52.     
  53.     def __init__(self):
  54.         self.failures = []
  55.         self.errors = []
  56.         self.testsRun = 0
  57.         self.shouldStop = 0
  58.  
  59.     
  60.     def startTest(self, test):
  61.         self.testsRun = self.testsRun + 1
  62.  
  63.     
  64.     def stopTest(self, test):
  65.         pass
  66.  
  67.     
  68.     def addError(self, test, err):
  69.         self.errors.append((test, self._exc_info_to_string(err, test)))
  70.  
  71.     
  72.     def addFailure(self, test, err):
  73.         self.failures.append((test, self._exc_info_to_string(err, test)))
  74.  
  75.     
  76.     def addSuccess(self, test):
  77.         pass
  78.  
  79.     
  80.     def wasSuccessful(self):
  81.         return None if len(self.errors) == len(self.errors) else len(self.errors) == 0
  82.  
  83.     
  84.     def stop(self):
  85.         self.shouldStop = True
  86.  
  87.     
  88.     def _exc_info_to_string(self, err, test):
  89.         (exctype, value, tb) = err
  90.         while tb and self._is_relevant_tb_level(tb):
  91.             tb = tb.tb_next
  92.         if exctype is test.failureException:
  93.             length = self._count_relevant_tb_levels(tb)
  94.             return ''.join(traceback.format_exception(exctype, value, tb, length))
  95.         
  96.         return ''.join(traceback.format_exception(exctype, value, tb))
  97.  
  98.     
  99.     def _is_relevant_tb_level(self, tb):
  100.         return tb.tb_frame.f_globals.has_key('__unittest')
  101.  
  102.     
  103.     def _count_relevant_tb_levels(self, tb):
  104.         length = 0
  105.         while tb and not self._is_relevant_tb_level(tb):
  106.             length += 1
  107.             tb = tb.tb_next
  108.         return length
  109.  
  110.     
  111.     def __repr__(self):
  112.         return '<%s run=%i errors=%i failures=%i>' % (_strclass(self.__class__), self.testsRun, len(self.errors), len(self.failures))
  113.  
  114.  
  115.  
  116. class TestCase:
  117.     failureException = AssertionError
  118.     
  119.     def __init__(self, methodName = 'runTest'):
  120.         
  121.         try:
  122.             self._testMethodName = methodName
  123.             testMethod = getattr(self, methodName)
  124.             self._testMethodDoc = testMethod.__doc__
  125.         except AttributeError:
  126.             raise ValueError, 'no such test method in %s: %s' % (self.__class__, methodName)
  127.  
  128.  
  129.     
  130.     def setUp(self):
  131.         pass
  132.  
  133.     
  134.     def tearDown(self):
  135.         pass
  136.  
  137.     
  138.     def countTestCases(self):
  139.         return 1
  140.  
  141.     
  142.     def defaultTestResult(self):
  143.         return TestResult()
  144.  
  145.     
  146.     def shortDescription(self):
  147.         doc = self._testMethodDoc
  148.         if not doc or doc.split('\n')[0].strip():
  149.             pass
  150.  
  151.     
  152.     def id(self):
  153.         return '%s.%s' % (_strclass(self.__class__), self._testMethodName)
  154.  
  155.     
  156.     def __str__(self):
  157.         return '%s (%s)' % (self._testMethodName, _strclass(self.__class__))
  158.  
  159.     
  160.     def __repr__(self):
  161.         return '<%s testMethod=%s>' % (_strclass(self.__class__), self._testMethodName)
  162.  
  163.     
  164.     def run(self, result = None):
  165.         if result is None:
  166.             result = self.defaultTestResult()
  167.         
  168.         result.startTest(self)
  169.         testMethod = getattr(self, self._testMethodName)
  170.         
  171.         try:
  172.             self.setUp()
  173.         except KeyboardInterrupt:
  174.             raise 
  175.         except:
  176.             result.addError(self, self._exc_info())
  177.             return None
  178.         
  179.  
  180.         ok = False
  181.         
  182.         try:
  183.             testMethod()
  184.             ok = True
  185.         except self.failureException:
  186.             result.addFailure(self, self._exc_info())
  187.         except KeyboardInterrupt:
  188.             raise 
  189.         except:
  190.             result.addError(self, self._exc_info())
  191.  
  192.         
  193.         try:
  194.             self.tearDown()
  195.         except KeyboardInterrupt:
  196.             raise 
  197.         except:
  198.             result.addError(self, self._exc_info())
  199.             ok = False
  200.  
  201.         if ok:
  202.             result.addSuccess(self)
  203.         result.stopTest(self)
  204.  
  205.     
  206.     def __call__(self, *args, **kwds):
  207.         return self.run(*args, **kwds)
  208.  
  209.     
  210.     def debug(self):
  211.         self.setUp()
  212.         getattr(self, self._testMethodName)()
  213.         self.tearDown()
  214.  
  215.     
  216.     def _exc_info(self):
  217.         (exctype, excvalue, tb) = sys.exc_info()
  218.         if sys.platform[:4] == 'java':
  219.             return (exctype, excvalue, tb)
  220.         
  221.         return (exctype, excvalue, tb)
  222.  
  223.     
  224.     def fail(self, msg = None):
  225.         raise self.failureException, msg
  226.  
  227.     
  228.     def failIf(self, expr, msg = None):
  229.         if expr:
  230.             raise self.failureException, msg
  231.         
  232.  
  233.     
  234.     def failUnless(self, expr, msg = None):
  235.         if not expr:
  236.             raise self.failureException, msg
  237.         
  238.  
  239.     
  240.     def failUnlessRaises(self, excClass, callableObj, *args, **kwargs):
  241.         
  242.         try:
  243.             callableObj(*args, **kwargs)
  244.         except excClass:
  245.             return None
  246.  
  247.         if hasattr(excClass, '__name__'):
  248.             excName = excClass.__name__
  249.         else:
  250.             excName = str(excClass)
  251.         raise self.failureException, '%s not raised' % excName
  252.  
  253.     
  254.     def failUnlessEqual(self, first, second, msg = None):
  255.         if not first == second:
  256.             if not msg:
  257.                 pass
  258.             raise self.failureException, '%r != %r' % (first, second)
  259.         
  260.  
  261.     
  262.     def failIfEqual(self, first, second, msg = None):
  263.         if first == second:
  264.             if not msg:
  265.                 pass
  266.             raise self.failureException, '%r == %r' % (first, second)
  267.         
  268.  
  269.     
  270.     def failUnlessAlmostEqual(self, first, second, places = 7, msg = None):
  271.         if round(second - first, places) != 0:
  272.             if not msg:
  273.                 pass
  274.             raise self.failureException, '%r != %r within %r places' % (first, second, places)
  275.         
  276.  
  277.     
  278.     def failIfAlmostEqual(self, first, second, places = 7, msg = None):
  279.         if round(second - first, places) == 0:
  280.             if not msg:
  281.                 pass
  282.             raise self.failureException, '%r == %r within %r places' % (first, second, places)
  283.         
  284.  
  285.     assertEqual = assertEquals = failUnlessEqual
  286.     assertNotEqual = assertNotEquals = failIfEqual
  287.     assertAlmostEqual = assertAlmostEquals = failUnlessAlmostEqual
  288.     assertNotAlmostEqual = assertNotAlmostEquals = failIfAlmostEqual
  289.     assertRaises = failUnlessRaises
  290.     assert_ = assertTrue = failUnless
  291.     assertFalse = failIf
  292.  
  293.  
  294. class TestSuite:
  295.     
  296.     def __init__(self, tests = ()):
  297.         self._tests = []
  298.         self.addTests(tests)
  299.  
  300.     
  301.     def __repr__(self):
  302.         return '<%s tests=%s>' % (_strclass(self.__class__), self._tests)
  303.  
  304.     __str__ = __repr__
  305.     
  306.     def __iter__(self):
  307.         return iter(self._tests)
  308.  
  309.     
  310.     def countTestCases(self):
  311.         cases = 0
  312.         for test in self._tests:
  313.             cases += test.countTestCases()
  314.         
  315.         return cases
  316.  
  317.     
  318.     def addTest(self, test):
  319.         if not callable(test):
  320.             raise TypeError('the test to add must be callable')
  321.         
  322.         if isinstance(test, (type, types.ClassType)) and issubclass(test, (TestCase, TestSuite)):
  323.             raise TypeError('TestCases and TestSuites must be instantiated before passing them to addTest()')
  324.         
  325.         self._tests.append(test)
  326.  
  327.     
  328.     def addTests(self, tests):
  329.         if isinstance(tests, basestring):
  330.             raise TypeError('tests must be an iterable of tests, not a string')
  331.         
  332.         for test in tests:
  333.             self.addTest(test)
  334.         
  335.  
  336.     
  337.     def run(self, result):
  338.         for test in self._tests:
  339.             if result.shouldStop:
  340.                 break
  341.             
  342.             test(result)
  343.         
  344.         return result
  345.  
  346.     
  347.     def __call__(self, *args, **kwds):
  348.         return self.run(*args, **kwds)
  349.  
  350.     
  351.     def debug(self):
  352.         for test in self._tests:
  353.             test.debug()
  354.         
  355.  
  356.  
  357.  
  358. class FunctionTestCase(TestCase):
  359.     
  360.     def __init__(self, testFunc, setUp = None, tearDown = None, description = None):
  361.         TestCase.__init__(self)
  362.         self._FunctionTestCase__setUpFunc = setUp
  363.         self._FunctionTestCase__tearDownFunc = tearDown
  364.         self._FunctionTestCase__testFunc = testFunc
  365.         self._FunctionTestCase__description = description
  366.  
  367.     
  368.     def setUp(self):
  369.         if self._FunctionTestCase__setUpFunc is not None:
  370.             self._FunctionTestCase__setUpFunc()
  371.         
  372.  
  373.     
  374.     def tearDown(self):
  375.         if self._FunctionTestCase__tearDownFunc is not None:
  376.             self._FunctionTestCase__tearDownFunc()
  377.         
  378.  
  379.     
  380.     def runTest(self):
  381.         self._FunctionTestCase__testFunc()
  382.  
  383.     
  384.     def id(self):
  385.         return self._FunctionTestCase__testFunc.__name__
  386.  
  387.     
  388.     def __str__(self):
  389.         return '%s (%s)' % (_strclass(self.__class__), self._FunctionTestCase__testFunc.__name__)
  390.  
  391.     
  392.     def __repr__(self):
  393.         return '<%s testFunc=%s>' % (_strclass(self.__class__), self._FunctionTestCase__testFunc)
  394.  
  395.     
  396.     def shortDescription(self):
  397.         if self._FunctionTestCase__description is not None:
  398.             return self._FunctionTestCase__description
  399.         
  400.         doc = self._FunctionTestCase__testFunc.__doc__
  401.         if not doc or doc.split('\n')[0].strip():
  402.             pass
  403.  
  404.  
  405.  
  406. class TestLoader:
  407.     testMethodPrefix = 'test'
  408.     sortTestMethodsUsing = cmp
  409.     suiteClass = TestSuite
  410.     
  411.     def loadTestsFromTestCase(self, testCaseClass):
  412.         if issubclass(testCaseClass, TestSuite):
  413.             raise TypeError('Test cases should not be derived from TestSuite. Maybe you meant to derive from TestCase?')
  414.         
  415.         testCaseNames = self.getTestCaseNames(testCaseClass)
  416.         if not testCaseNames and hasattr(testCaseClass, 'runTest'):
  417.             testCaseNames = [
  418.                 'runTest']
  419.         
  420.         return self.suiteClass(map(testCaseClass, testCaseNames))
  421.  
  422.     
  423.     def loadTestsFromModule(self, module):
  424.         tests = []
  425.         for name in dir(module):
  426.             obj = getattr(module, name)
  427.             if isinstance(obj, (type, types.ClassType)) and issubclass(obj, TestCase):
  428.                 tests.append(self.loadTestsFromTestCase(obj))
  429.                 continue
  430.         
  431.         return self.suiteClass(tests)
  432.  
  433.     
  434.     def loadTestsFromName(self, name, module = None):
  435.         parts = name.split('.')
  436.         if module is None:
  437.             parts_copy = parts[:]
  438.             while parts_copy:
  439.                 
  440.                 try:
  441.                     module = __import__('.'.join(parts_copy))
  442.                 continue
  443.                 except ImportError:
  444.                     del parts_copy[-1]
  445.                     if not parts_copy:
  446.                         raise 
  447.                     
  448.                     parts_copy
  449.                 
  450.  
  451.                 None<EXCEPTION MATCH>ImportError
  452.             parts = parts[1:]
  453.         
  454.         obj = module
  455.         for part in parts:
  456.             parent = obj
  457.             obj = getattr(obj, part)
  458.         
  459.         if type(obj) == types.ModuleType:
  460.             return self.loadTestsFromModule(obj)
  461.         elif isinstance(obj, (type, types.ClassType)) and issubclass(obj, TestCase):
  462.             return self.loadTestsFromTestCase(obj)
  463.         elif type(obj) == types.UnboundMethodType:
  464.             return parent(obj.__name__)
  465.         elif isinstance(obj, TestSuite):
  466.             return obj
  467.         elif callable(obj):
  468.             test = obj()
  469.             if not isinstance(test, (TestCase, TestSuite)):
  470.                 raise ValueError, 'calling %s returned %s, not a test' % (obj, test)
  471.             
  472.             return test
  473.         else:
  474.             raise ValueError, "don't know how to make test from: %s" % obj
  475.  
  476.     
  477.     def loadTestsFromNames(self, names, module = None):
  478.         suites = [ self.loadTestsFromName(name, module) for name in names ]
  479.         return self.suiteClass(suites)
  480.  
  481.     
  482.     def getTestCaseNames(self, testCaseClass):
  483.         
  484.         def isTestMethod(attrname, testCaseClass = testCaseClass, prefix = self.testMethodPrefix):
  485.             if attrname.startswith(prefix):
  486.                 pass
  487.             return callable(getattr(testCaseClass, attrname))
  488.  
  489.         testFnNames = filter(isTestMethod, dir(testCaseClass))
  490.         for baseclass in testCaseClass.__bases__:
  491.             for testFnName in self.getTestCaseNames(baseclass):
  492.                 if testFnName not in testFnNames:
  493.                     testFnNames.append(testFnName)
  494.                     continue
  495.             
  496.         
  497.         if self.sortTestMethodsUsing:
  498.             testFnNames.sort(self.sortTestMethodsUsing)
  499.         
  500.         return testFnNames
  501.  
  502.  
  503. defaultTestLoader = TestLoader()
  504.  
  505. def _makeLoader(prefix, sortUsing, suiteClass = None):
  506.     loader = TestLoader()
  507.     loader.sortTestMethodsUsing = sortUsing
  508.     loader.testMethodPrefix = prefix
  509.     if suiteClass:
  510.         loader.suiteClass = suiteClass
  511.     
  512.     return loader
  513.  
  514.  
  515. def getTestCaseNames(testCaseClass, prefix, sortUsing = cmp):
  516.     return _makeLoader(prefix, sortUsing).getTestCaseNames(testCaseClass)
  517.  
  518.  
  519. def makeSuite(testCaseClass, prefix = 'test', sortUsing = cmp, suiteClass = TestSuite):
  520.     return _makeLoader(prefix, sortUsing, suiteClass).loadTestsFromTestCase(testCaseClass)
  521.  
  522.  
  523. def findTestCases(module, prefix = 'test', sortUsing = cmp, suiteClass = TestSuite):
  524.     return _makeLoader(prefix, sortUsing, suiteClass).loadTestsFromModule(module)
  525.  
  526.  
  527. class _WritelnDecorator:
  528.     
  529.     def __init__(self, stream):
  530.         self.stream = stream
  531.  
  532.     
  533.     def __getattr__(self, attr):
  534.         return getattr(self.stream, attr)
  535.  
  536.     
  537.     def writeln(self, arg = None):
  538.         if arg:
  539.             self.write(arg)
  540.         
  541.         self.write('\n')
  542.  
  543.  
  544.  
  545. class _TextTestResult(TestResult):
  546.     separator1 = '=' * 70
  547.     separator2 = '-' * 70
  548.     
  549.     def __init__(self, stream, descriptions, verbosity):
  550.         TestResult.__init__(self)
  551.         self.stream = stream
  552.         self.showAll = verbosity > 1
  553.         self.dots = verbosity == 1
  554.         self.descriptions = descriptions
  555.  
  556.     
  557.     def getDescription(self, test):
  558.         if self.descriptions:
  559.             if not test.shortDescription():
  560.                 pass
  561.             return str(test)
  562.         else:
  563.             return str(test)
  564.  
  565.     
  566.     def startTest(self, test):
  567.         TestResult.startTest(self, test)
  568.         if self.showAll:
  569.             self.stream.write(self.getDescription(test))
  570.             self.stream.write(' ... ')
  571.         
  572.  
  573.     
  574.     def addSuccess(self, test):
  575.         TestResult.addSuccess(self, test)
  576.         if self.showAll:
  577.             self.stream.writeln('ok')
  578.         elif self.dots:
  579.             self.stream.write('.')
  580.         
  581.  
  582.     
  583.     def addError(self, test, err):
  584.         TestResult.addError(self, test, err)
  585.         if self.showAll:
  586.             self.stream.writeln('ERROR')
  587.         elif self.dots:
  588.             self.stream.write('E')
  589.         
  590.  
  591.     
  592.     def addFailure(self, test, err):
  593.         TestResult.addFailure(self, test, err)
  594.         if self.showAll:
  595.             self.stream.writeln('FAIL')
  596.         elif self.dots:
  597.             self.stream.write('F')
  598.         
  599.  
  600.     
  601.     def printErrors(self):
  602.         if self.dots or self.showAll:
  603.             self.stream.writeln()
  604.         
  605.         self.printErrorList('ERROR', self.errors)
  606.         self.printErrorList('FAIL', self.failures)
  607.  
  608.     
  609.     def printErrorList(self, flavour, errors):
  610.         for test, err in errors:
  611.             self.stream.writeln(self.separator1)
  612.             self.stream.writeln('%s: %s' % (flavour, self.getDescription(test)))
  613.             self.stream.writeln(self.separator2)
  614.             self.stream.writeln('%s' % err)
  615.         
  616.  
  617.  
  618.  
  619. class TextTestRunner:
  620.     
  621.     def __init__(self, stream = sys.stderr, descriptions = 1, verbosity = 1):
  622.         self.stream = _WritelnDecorator(stream)
  623.         self.descriptions = descriptions
  624.         self.verbosity = verbosity
  625.  
  626.     
  627.     def _makeResult(self):
  628.         return _TextTestResult(self.stream, self.descriptions, self.verbosity)
  629.  
  630.     
  631.     def run(self, test):
  632.         result = self._makeResult()
  633.         startTime = time.time()
  634.         test(result)
  635.         stopTime = time.time()
  636.         timeTaken = stopTime - startTime
  637.         result.printErrors()
  638.         self.stream.writeln(result.separator2)
  639.         run = result.testsRun
  640.         if not run != 1 or 's':
  641.             pass
  642.         self.stream.writeln('Ran %d test%s in %.3fs' % (run, '', timeTaken))
  643.         self.stream.writeln()
  644.         if not result.wasSuccessful():
  645.             self.stream.write('FAILED (')
  646.             (failed, errored) = map(len, (result.failures, result.errors))
  647.             if failed:
  648.                 self.stream.write('failures=%d' % failed)
  649.             
  650.             if errored:
  651.                 if failed:
  652.                     self.stream.write(', ')
  653.                 
  654.                 self.stream.write('errors=%d' % errored)
  655.             
  656.             self.stream.writeln(')')
  657.         else:
  658.             self.stream.writeln('OK')
  659.         return result
  660.  
  661.  
  662.  
  663. class TestProgram:
  664.     USAGE = "Usage: %(progName)s [options] [test] [...]\n\nOptions:\n  -h, --help       Show this message\n  -v, --verbose    Verbose output\n  -q, --quiet      Minimal output\n\nExamples:\n  %(progName)s                               - run default set of tests\n  %(progName)s MyTestSuite                   - run suite 'MyTestSuite'\n  %(progName)s MyTestCase.testSomething      - run MyTestCase.testSomething\n  %(progName)s MyTestCase                    - run all 'test*' test methods\n                                               in MyTestCase\n"
  665.     
  666.     def __init__(self, module = '__main__', defaultTest = None, argv = None, testRunner = None, testLoader = defaultTestLoader):
  667.         if type(module) == type(''):
  668.             self.module = __import__(module)
  669.             for part in module.split('.')[1:]:
  670.                 self.module = getattr(self.module, part)
  671.             
  672.         else:
  673.             self.module = module
  674.         if argv is None:
  675.             argv = sys.argv
  676.         
  677.         self.verbosity = 1
  678.         self.defaultTest = defaultTest
  679.         self.testRunner = testRunner
  680.         self.testLoader = testLoader
  681.         self.progName = os.path.basename(argv[0])
  682.         self.parseArgs(argv)
  683.         self.runTests()
  684.  
  685.     
  686.     def usageExit(self, msg = None):
  687.         if msg:
  688.             print msg
  689.         
  690.         print self.USAGE % self.__dict__
  691.         sys.exit(2)
  692.  
  693.     
  694.     def parseArgs(self, argv):
  695.         import getopt as getopt
  696.         
  697.         try:
  698.             (options, args) = getopt.getopt(argv[1:], 'hHvq', [
  699.                 'help',
  700.                 'verbose',
  701.                 'quiet'])
  702.             for opt, value in options:
  703.                 if opt in ('-h', '-H', '--help'):
  704.                     self.usageExit()
  705.                 
  706.                 if opt in ('-q', '--quiet'):
  707.                     self.verbosity = 0
  708.                 
  709.                 if opt in ('-v', '--verbose'):
  710.                     self.verbosity = 2
  711.                     continue
  712.             
  713.             if len(args) == 0 and self.defaultTest is None:
  714.                 self.test = self.testLoader.loadTestsFromModule(self.module)
  715.                 return None
  716.             
  717.             if len(args) > 0:
  718.                 self.testNames = args
  719.             else:
  720.                 self.testNames = (self.defaultTest,)
  721.             self.createTests()
  722.         except getopt.error:
  723.             msg = None
  724.             self.usageExit(msg)
  725.  
  726.  
  727.     
  728.     def createTests(self):
  729.         self.test = self.testLoader.loadTestsFromNames(self.testNames, self.module)
  730.  
  731.     
  732.     def runTests(self):
  733.         if self.testRunner is None:
  734.             self.testRunner = TextTestRunner(verbosity = self.verbosity)
  735.         
  736.         result = self.testRunner.run(self.test)
  737.         sys.exit(not result.wasSuccessful())
  738.  
  739.  
  740. main = TestProgram
  741. if __name__ == '__main__':
  742.     main(module = None)
  743.  
  744.